package com.yx.changdao.web.controller;

import com.yx.changdao.common.annotation.AutoLog;
import com.yx.changdao.common.annotation.ShiroDesc;
import com.yx.changdao.common.data.Result;
import com.yx.changdao.common.entity.SysPermission;
import com.yx.changdao.common.entity.SysRolePermission;
import com.yx.changdao.common.exception.AlertException;
import com.yx.changdao.common.utils.ParseDictUtils;
import com.yx.changdao.common.utils.SysUtils;
import com.yx.changdao.service.SysPermissionService;
import com.yx.changdao.service.SysRolePermissionService;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description: <br />
 * 角色权限接口
 * <p>
 * <br />
 * @Auther: Zhangjiashun
 * @create 2019/11/18 13:48
 */
@RestController
@RequestMapping(value = "/sys/role/permission", produces = {"application/json;charset=UTF-8"})
public class SysRolePermissionController {
    private final SysRolePermissionService sysRolePermissionService;
    private final SysPermissionService sysPermissionService;

    public SysRolePermissionController(SysRolePermissionService sysRolePermissionService, SysPermissionService sysPermissionService) {
        this.sysRolePermissionService = sysRolePermissionService;
        this.sysPermissionService = sysPermissionService;
    }

    /**
     * 用户角色权限列表
     *
     * @return Result
     */
    @AutoLog
    @GetMapping("/list")
    @RequiresPermissions("sys:rolepermission:list")
    @ShiroDesc("系统角色权限:列表")
    public Result list() throws AlertException {
        // 根据传入 条件获取角色权限列表
        List<SysRolePermission> rolePermissionList =
                this.sysRolePermissionService.list(SysUtils.autoCnd(SysRolePermission.class));

        // 按角色id进行分组。
        Map<String, List<SysRolePermission>> roleHasPermissionsMap =
                rolePermissionList.stream().collect(Collectors.groupingBy(SysRolePermission::getRoleId));

        // 角色对应的多个权限。
        Map<String, List<String>> roleHasPermissionIdsMap = new HashMap<>();

        // permission转成id返回。
        roleHasPermissionsMap.forEach((key, val) -> {
            List<String> permission = new ArrayList<>();
            val.forEach(rolePermission -> permission.add(rolePermission.getPermId()));
            roleHasPermissionIdsMap.put(key, permission);
        });

        return Result.ok().data(roleHasPermissionIdsMap);
    }


    /**
     * 为指定角色添加权限
     *
     * @param rolePermission 权限id和角色id
     * @return Result
     */
    @AutoLog
    @PostMapping
    @RequiresPermissions("sys:rolepermission:add")
    @ShiroDesc("系统角色权限:添加")
    public Result add(SysRolePermission rolePermission) throws AlertException {
        SysRolePermission sysRolePermission = this.sysRolePermissionService.addRolePermission(rolePermission);

        if (sysRolePermission == null) {
            throw new AlertException("角色权限添加失败");
        }
        return Result.ok("角色权限添加成功").data(sysRolePermission);
    }

    /**
     * 获得指定 角色 拥有的权限列表。
     *
     * @param roleId 角色id
     * @return Result
     */
    @AutoLog
    @GetMapping("/{id}")
    @RequiresPermissions("sys:rolepermission:look")
    @ShiroDesc("系统角色权限:查看")
    public Result get(@PathVariable("id") String roleId) throws AlertException {

        // 所有符合条件的权限列表。
        List<SysPermission> sysPermissionList =
                this.sysPermissionService.list(SysUtils.autoCnd(SysPermission.class));

        // 查询这个角色拥有的权限。
        List<SysPermission> rolePermissions =
                this.sysRolePermissionService.getRolePermissions(roleId);

        // 角色已有权限转id。
        List<String> permissionIds = rolePermissions.stream()
                .map(SysPermission::getPermId)
                .collect(Collectors.toList());

        // 存放权限关系。 
        List<Map<String, Object>> permissions = new ArrayList<>();

        // 将已有的权限设置 active 为true；
        sysPermissionList.forEach(permission -> {
            Map<String, Object> permRelationMap;
            // 将对象解析为map。
            permRelationMap = ParseDictUtils.parseItem(permission);
            boolean active = false;
            if (permissionIds.contains(permission.getPermId())) {
                active = true;
            }
            permRelationMap.put("active", active);
            permissions.add(permRelationMap);
        });

        // 按权限描述前缀进行分组
        Map<String, List<Map<String, Object>>> grpByPerPermMap = permissions.stream().collect(Collectors.groupingBy(map -> {
            Object obj = map.get(SysPermission.PERM_NAME);
            if (obj == null) {
                return "";
            }
            String[] split = obj.toString().split("[:：]");
            return split[0];
        }));

//        Map map = new HashMap();
//        map.put("allPermissions", grpByPerPermMap);
//        map.put("hasPermission", permissionIds);
        return Result.ok().data(grpByPerPermMap);
    }


    /**
     * 删除角色的指定权限
     *
     * @param roleId 待删除用户角色id
     * @return Result
     */
    @AutoLog
    @DeleteMapping("/{roleId}/{permissionId}")
    @RequiresPermissions("sys:rolepermission:del")
    @ShiroDesc("系统角色权限:删除")
    public Result delete(@PathVariable("roleId") String roleId, @PathVariable("permissionId") String permissionId) throws AlertException {
        boolean b = this.sysRolePermissionService.delRolePermissions(roleId, permissionId);
        if (!b) {
            throw new AlertException("删除角色权限失败");
        }
        return Result.ok("删除角色权限成功");
    }


}
